{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io\n",
    "import os\n",
    "import platform\n",
    "import pdb\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from matplotlib.pyplot import cm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from sklearn import preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=pd.read_csv('shanghai.csv')\n",
    "dataset=data.iloc[:,-1].copy()\n",
    "dataset.replace(9999,np.nan,inplace=True)\n",
    "dataset.replace(-999,np.nan,inplace=True)\n",
    "for i in range(len(data)):\n",
    "    if np.isnan(dataset.iat[i]):\n",
    "        if i==0:\n",
    "            dataset.iloc[i]=dataset.iat[i+1]\n",
    "        elif i==len(data)-1:\n",
    "            dataset.iloc[i]=dataset.iat[i-1]\n",
    "        else:\n",
    "            dataset.iloc[i]=np.nanmean([dataset.iat[i-1],dataset.iat[i+1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = preprocessing.MinMaxScaler() \n",
    "scaled_values = scaler.fit_transform(pd.DataFrame(dataset))\n",
    "# dataset.iloc[:] = np.squeeze(scaled_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_set=np.asarray(dataset,dtype=np.float32)\n",
    "seq_len=30 + 1\n",
    "x=len(data_set)-seq_len\n",
    "sequences = [data_set[t:t+seq_len] for t in range(x)]\n",
    "for i in range(len(sequences)):\n",
    "    sequences[i]=scaler.fit_transform(sequences[i].reshape(-1,1))\n",
    "seq=torch.FloatTensor(sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_row=round(0.90*seq.size(0))\n",
    "x_train_set=seq[:split_row, :-1]\n",
    "y_train_set=seq[:split_row, -1]\n",
    "x_valid_set=seq[split_row:, :-1]\n",
    "y_valid_set=seq[split_row:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self,input_size,hidden_size,num_layers=2,dropout=0,bidirectional=False):\n",
    "        super(LSTM,self).__init__()\n",
    "        self.input_size=input_size\n",
    "        self.hidden_size=hidden_size\n",
    "        self.num_layers=num_layers\n",
    "        self.dropout=dropout\n",
    "        self.bidirectional=bidirectional\n",
    "        self.lstm = nn.LSTM(input_size,\n",
    "                            hidden_size,\n",
    "                            num_layers,\n",
    "                            dropout=dropout,\n",
    "                            bidirectional=bidirectional)\n",
    "        self.linear = nn.Linear(hidden_size, input_size)\n",
    "        \n",
    "    def forward(self,inputs,hidden):\n",
    "        outputs,hidden=self.lstm(inputs,hidden)\n",
    "        predictions=self.linear(outputs[-1])\n",
    "        return predictions,outputs,hidden\n",
    "    \n",
    "    def init_hidden(self,batch_size):\n",
    "        num_directions=2 if self.bidirectional else 1\n",
    "        hidden = (torch.zeros(self.num_layers*num_directions, batch_size, self.hidden_size),\n",
    "                  torch.zeros(self.num_layers*num_directions, batch_size, self.hidden_size))\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_batch(x,y,i,batch_size):\n",
    "    if x.dim() == 2:\n",
    "        x = x.unsqueeze(2)\n",
    "    batch_x = x[(i*batch_size):(i*batch_size)+batch_size, :, :]\n",
    "    batch_y = y[(i*batch_size):(i*batch_size)+batch_size]\n",
    "\n",
    "    # Reshape Tensors into (seq_len, batch_size, input_size) format for the LSTM.\n",
    "    batch_x = batch_x.transpose(0, 1)\n",
    "    \n",
    "    return batch_x, batch_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model,x_train_set,y_train_set,optimizer,batch_size,epoch):\n",
    "    num_sequences=x_train_set.size(0)\n",
    "    num_batches=num_sequences//batch_size\n",
    "    \n",
    "    total_loss=0\n",
    "    \n",
    "    model.train()\n",
    "    for i in range(num_batches):\n",
    "        # Get input and target batches and reshape for LSTM.\n",
    "        batch_x, batch_y = get_batch(x_train_set, y_train_set, i, batch_size)\n",
    "\n",
    "        # Reset the gradient.\n",
    "        lstm.zero_grad()\n",
    "        \n",
    "        # Initialize the hidden states (see the function lstm.init_hidden(batch_size)).\n",
    "        hidden = lstm.init_hidden(batch_size)\n",
    "        \n",
    "        # Complete a forward pass.\n",
    "        y_pred, outputs, hidden = lstm(batch_x,hidden)\n",
    "        \n",
    "        # Calculate the loss with the 'loss_fn'.\n",
    "        loss = loss_fn(y_pred,batch_y)\n",
    "        \n",
    "        # Compute the gradient.\n",
    "        loss.backward()\n",
    "        \n",
    "        # Clip to the gradient to avoid exploding gradient.\n",
    "        nn.utils.clip_grad_norm_(lstm.parameters(), max_grad_norm)\n",
    "\n",
    "        # Make one step with optimizer.\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Accumulate the total loss.\n",
    "        total_loss += loss.data\n",
    "        \n",
    "    print(\"Epoch {}: Loss = {:.8f}\".format(epoch+1, total_loss/num_batches))\n",
    "    return total_loss/num_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval(model,x_valid_set,y_valid_set,optimizer,batch_size):\n",
    "    num_sequences=x_valid_set.size(0)\n",
    "    num_batches=num_sequences//batch_size\n",
    "    \n",
    "    total_loss=0\n",
    "    \n",
    "    model.eval()\n",
    "    for i in range(num_batches):\n",
    "        # Get input and target batches and reshape for LSTM.\n",
    "        batch_x, batch_y = get_batch(x_valid_set, y_valid_set, i, batch_size)\n",
    "\n",
    "        # Reset the gradient.\n",
    "        lstm.zero_grad()\n",
    "        \n",
    "        # Initialize the hidden states (see the function lstm.init_hidden(batch_size)).\n",
    "        hidden = lstm.init_hidden(batch_size)\n",
    "        \n",
    "        # Complete a forward pass.\n",
    "        y_pred, outputs, hidden = lstm(batch_x,hidden)\n",
    "        \n",
    "        # Calculate the loss with the 'loss_fn'.\n",
    "        loss = loss_fn(y_pred,batch_y)\n",
    "        \n",
    "        # Compute the gradient.\n",
    "        loss.backward()\n",
    "        \n",
    "        # Clip to the gradient to avoid exploding gradient.\n",
    "        nn.utils.clip_grad_norm_(lstm.parameters(), max_grad_norm)\n",
    "\n",
    "        # Make one step with optimizer.\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Accumulate the total loss.\n",
    "        total_loss += loss.data\n",
    "\n",
    "    print(\"Validation: Loss = {:.8f}\".format(total_loss/num_batches))\n",
    "    return total_loss/num_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(epoch, model, path='./'):\n",
    "    \n",
    "    # file name and path \n",
    "    filename = path + 'shanghai.pt'\n",
    "    \n",
    "    # load the model parameters \n",
    "    torch.save(model.state_dict(), filename)\n",
    "    \n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model for 30 epoch\n",
      "Epoch 1: Loss = 0.15023826\n",
      "Validation: Loss = 0.07899629\n",
      "Epoch 2: Loss = 0.07027372\n",
      "Validation: Loss = 0.06005255\n",
      "Epoch 3: Loss = 0.05309143\n",
      "Validation: Loss = 0.05417275\n",
      "Epoch 4: Loss = 0.04539443\n",
      "Validation: Loss = 0.05054011\n",
      "Epoch 5: Loss = 0.03972043\n",
      "Validation: Loss = 0.04862384\n",
      "Epoch 6: Loss = 0.03626834\n",
      "Validation: Loss = 0.04820058\n",
      "Epoch 7: Loss = 0.03444175\n",
      "Validation: Loss = 0.04860127\n",
      "Epoch 8: Loss = 0.03355629\n",
      "Validation: Loss = 0.04920935\n",
      "Epoch 9: Loss = 0.03317947\n",
      "Validation: Loss = 0.04965448\n",
      "Epoch 10: Loss = 0.03303186\n",
      "Validation: Loss = 0.04987169\n",
      "Epoch 11: Loss = 0.03296779\n",
      "Validation: Loss = 0.04994378\n",
      "Epoch 12: Loss = 0.03293171\n",
      "Validation: Loss = 0.04994828\n",
      "Epoch 13: Loss = 0.03290562\n",
      "Validation: Loss = 0.04992795\n",
      "Epoch 14: Loss = 0.03288341\n",
      "Validation: Loss = 0.04990149\n",
      "Epoch 15: Loss = 0.03286305\n",
      "Validation: Loss = 0.04987580\n",
      "Epoch 16: Loss = 0.03284381\n",
      "Validation: Loss = 0.04985295\n",
      "Epoch 17: Loss = 0.03282524\n",
      "Validation: Loss = 0.04983322\n",
      "Epoch 18: Loss = 0.03280725\n",
      "Validation: Loss = 0.04981637\n",
      "Epoch 19: Loss = 0.03278953\n",
      "Validation: Loss = 0.04980199\n",
      "Epoch 20: Loss = 0.03277173\n",
      "Validation: Loss = 0.04978966\n",
      "Epoch 21: Loss = 0.03275359\n",
      "Validation: Loss = 0.04977897\n",
      "Epoch 22: Loss = 0.03273463\n",
      "Validation: Loss = 0.04976966\n",
      "Epoch 23: Loss = 0.03271434\n",
      "Validation: Loss = 0.04976168\n",
      "Epoch 24: Loss = 0.03269199\n",
      "Validation: Loss = 0.04975510\n",
      "Epoch 25: Loss = 0.03266683\n",
      "Validation: Loss = 0.04974994\n",
      "Epoch 26: Loss = 0.03263766\n",
      "Validation: Loss = 0.04974541\n",
      "Epoch 27: Loss = 0.03260326\n",
      "Validation: Loss = 0.04973938\n",
      "Epoch 28: Loss = 0.03256240\n",
      "Validation: Loss = 0.04972738\n",
      "Epoch 29: Loss = 0.03251459\n",
      "Validation: Loss = 0.04970339\n",
      "Epoch 30: Loss = 0.03246123\n",
      "Validation: Loss = 0.04966288\n",
      "\n",
      "\n",
      "\n",
      "Optimization ended.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_size=1\n",
    "hidden_size=24\n",
    "num_layers=2\n",
    "lstm=LSTM(input_size,hidden_size)\n",
    "\n",
    "learning_rate=0.0001\n",
    "max_grad_norm=5\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = optim.Adam(lstm.parameters(), lr=learning_rate,weight_decay=0.000001)\n",
    "\n",
    "batch_size = 8\n",
    "num_epochs = 30 #3\n",
    "# num_sequences = x_train_set.size(0)\n",
    "# num_batches = num_sequences //batch_size\n",
    "\n",
    "checkpoint_freq = 10\n",
    "path = './'\n",
    "\n",
    "train_losses=[]\n",
    "valid_losses=[]\n",
    "\n",
    "print(\"Training model for {} epoch\".format(num_epochs))\n",
    "for epoch in range(num_epochs):\n",
    "#     total_loss = 0\n",
    "\n",
    "    # Shuffle input and target sequences.\n",
    "    idx = torch.randperm(x_train_set.size(0))\n",
    "    x = x_train_set[idx]\n",
    "    y = y_train_set[idx]\n",
    "    \n",
    "    train_loss=train(lstm,x_train_set,y_train_set,optimizer,batch_size,epoch)\n",
    "    valid_loss=eval(lstm,x_valid_set,y_valid_set,optimizer,batch_size)\n",
    "    \n",
    "    train_losses.append(train_loss)\n",
    "    valid_losses.append(valid_loss)\n",
    "    \n",
    "    # Checkpoint\n",
    "    if epoch % checkpoint_freq ==0:\n",
    "        save_model(epoch, lstm, path)\n",
    "        \n",
    "# Last checkpoint\n",
    "save_model(num_epochs, lstm, path)\n",
    "    \n",
    "print(\"\\n\\n\\nOptimization ended.\\n\")\n",
    "\n",
    "plt.plot(train_losses, color=\"darkcyan\", label=\"train\")\n",
    "plt.plot(valid_losses, color=\"tomato\",label=\"validation\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_one_hour(model,x_valid_set,input_size,num_steps):\n",
    "    predictions=torch.zeros(num_steps)\n",
    "    for i, x in enumerate(x_valid_set):\n",
    "        hidden=model.init_hidden(1)\n",
    "        y_pred,_,_=model(x.contiguous().view(-1, 1, input_size),hidden)\n",
    "        predictions[i]=y_pred\n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_step_predictions = predict_one_hour(lstm, x_valid_set, input_size, y_valid_set.size(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(y_valid_set.data.numpy(),color='darkcyan')\n",
    "plt.plot(one_step_predictions.data.numpy(),color='tomato')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
